Deklaration einer Methode

Syntax 
METHOD (* optional_begin *) PUBLIC|PROTECTED|PRIVATE|INTERNAL FINAL|ABSTRACT OVERRIDE (* optional_end *) name_1 (* optional_begin *) : type (* optional_end *) 
 
(* optional: declaration of variables/instances *)
 
(* optional: body of method *)
 
END_METHOD
Bedeutung

Deklaration einer bzw. mehrerer →Methoden (ein Feature der →objektorientierten Programmierung) , wobei name_1 ein →IEC-Bezeichner sein muss. 
Die Deklaration mehrerer solcher Abschnitte ist zulässig. Die Deklaration ist innerhalb der Deklaration eines →Funktionsbausteins oder einer →Klasse möglich. Eine eingeschränkte Deklaration einer Methode ist als →Methoden-Prototypen bei einem →Interface möglich (siehe "Deklaration eines Interfaces mit Methoden-Prototypen" für diese Einschränkungen).

Beachten Sie:

Mögliche Schlüsselwörter für eine Methode

Mit Hilfe eines optionalen Schlüsselworts (= Modifizierer) definieren Sie, wo die Methode sichtbar ist (wenn in der Tabelle ein Funktionsbaustein angeführt ist, so gilt die Beschreibung auch für die Klasse):

Modifizierer

Bedeutung

PUBLIC

Öffentlicher Aufruf: Die Methode kann von überall aufgerufen werden.

PROTECTED (oder keiner)

Geschützter Aufruf (Standard): Die Methode kann von innerhalb des Funktionsbausteins aufgerufen werden, in der sie definiert ist. Zusätzlich kann sie in abgeleiteten Funktionsbausteinen aufgerufen werden.

Falls keine abgeleitete Funktionsbausteine vorhanden sind, hat PROTECTED die gleiche Bedeutung wie PRIVATE.

PRIVATE

Privater Aufruf: Die Methode kann nur von innerhalb des Funktionsbaustein aufgerufen werden, in der sie definiert ist.

INTERNAL

Interner Aufruf: Die Methode kann nur von innerhalb des gleichen →Namespaces aufgerufen werden.

Zusätzlich können Sie diese Schlüsselwörter angeben:

FINAL 

Die aktuelle Methode kann nicht ersetzt, d.h. überschrieben, werden.

Verwenden Sie FINAL, falls die aktuelle Methode in keinem der abgeleiteten Funktionsbausteine überschreibbar sein soll (siehe das folgende Beispiel 5). FINAL kann nicht gemeinsam mit ABSTRACT verwendet werden.

ABSTRACT 

Die aktuelle Methode ist eine abstrakte Methode.

Verwenden Sie ABSTRACT, falls die aktuelle Methode in einem abgeleiteten Funktionsbaustein implementiert werden soll. Der Funktionsbaustein, in dem die abstrakte Methode deklariert ist, muss ein abstrakter Funktionsbaustein sein (= ein Funktionsbaustein mit dem Schlüsselwort ABSTRACT; siehe das folgende Beispiel 4). Weitere Hinweise zur Verwendung von ABSTRACT:

  • ABSTRACT darf nur für Methoden eines abstrakten Funktionsbausteins verwendet werden.

  • ABSTRACT kann nicht gemeinsam mit OVERRIDE verwendet werden.

  • Ein abstrakte Methode darf keine Anweisungen (keinen Body) enthalten.

Als Folge müssen alle abstrakten Methoden des abstrakten Funktionsbausteins in einem nicht-abstrakten Funktionsbaustein implementiert werden, der vom abstrakten Funktionsbaustein abgeleitet wird.

OVERRIDE 

Die aktuelle Methode ersetzt, d.h. überschreibt, eine andere Methode mit dem gleichen Namen.

Verwenden Sie OVERRIDE, um eine Methode des Basis-Funktionsbaustein durch die aktuelle Methode im abgeleiteten Funktionsbaustein zu ersetzen (siehe Informationen zum Schlüsselwort EXTENDS unter "Deklaration eines Funktionsbausteins in ST" und das folgende Beispiel 3).Weitere Hinweise zur Verwendung von OVERRIDE:

  • Nur Methoden, die im abgeleiteten Funktionsbaustein sichtbar sind, können überschrieben werden. Das bedeutet, die Methode muss mit dem Schlüsselwort PUBLIC, PROTECTED oder INTERNAL im gleichen Namespace deklariert sein.

  • Die →Signaturen der aktuellen Methode (im abgeleiteten Funktionsbaustein) und der überschriebenen Methode (im Basis-Funktionsbaustein) müssen übereinstimmen. Das bedeutet, dass die Namen der Methoden und die Reihenfolge aller ihrer Parameter ( Eingänge, Ausgänge, Ein-/Ausgangsvariablen und Ergebnistyp) übereinstimmen müssen.

  • Die Schlüsselwörter der aktuellen Methode und der überschriebenen Methode müssen ebenfalls übereinstimmen. Ausnahme: Bei der aktuellen Methode darf das Schlüsselwort FINAL angegeben werden.

  • ABSTRACT kann nicht gemeinsam mit OVERRIDE verwendet werden.

 

Der Datentyp : data-type  ist optional, allerdings zwingend erforderlich, falls ein Ergebniswert innerhalb der Methode zugewiesen wird (siehe Methode UP im folgenden Beispiel: Zuweisung UP:= CV;) oder die Methode als Operand zu verwenden ist.
Informieren Sie sich unter "Unterstützte Datentypen", welche Datentypen Sie für die Deklaration von Variablen angeben können.

Abweichungen von IEC-Norm

Bei Neuron Power Engineer muss der Name einer Methode im gleichen →Gültigkeitsbereich eindeutig sein. Dies steht im Gegensatz zur →IEC-Norm, in der die →Signatur zum eindeutigen Identifizieren einer Methode verwendet wird.

 

 

Gut zu wissen

(Graue Glühbirne)Eine Methode verhält sich wie eine →Funktion.

In einer Methode dürfen Sie die folgenden Sprachelemente für ST verwenden:

Zuweisungen in ST

Leerzeichen, Tabulator oder Leerzeilen in ST

Aufruf der Funktionsbaustein-Instanz in ST

Aufruf der Funktion in ST

Aufruf der Methode in ST

CASE-Anweisung in ST

Kommentare in ST

CONTINUE-Anweisung in ST

Deklaration von externen Variablen in ST

Deklaration von Ein-/Ausgangsvariablen in ST

Deklaration von Eingangsvariablen in ST

Deklaration von internen Variablen

Deklaration von Ausgangsvariablen in ST

Deklaration von temporären Variablen in ST

Leer-Anweisung in ST

EXIT-Anweisung in ST

FOR-Anweisung in ST

IF-Anweisung in ST

Eigenschafts-Anweisung in ST

REPEAT-Anweisung in ST

RETURN-Anweisung in ST

WHILE-Anweisung in ST

Durch die Verwendung von Sprachelementen können Sie auch andere Elemente (z.B. Deklaration von STRING-Variablen im Abschnitt VAR ... END_VAR) verwenden. Dieses Elemente sind in der obigen Liste nicht angeführt.

Beispiel 1: Funktionsbaustein mit 2 Methoden zum Hochzählen

 
FUNCTION_BLOCK CounterWithMethod
  VAR
    CV: UINT;                          // Current value of counter
    Max: UINT:= 1000;
  END_VAR
 
  METHOD PUBLIC UP: UINT               // Method for count up by inc
    VAR_INPUT INC: UINT; END_VAR       // Increment  
    VAR_OUTPUT QU: BOOL; END_VAR       // Upper limit detection
 
    IF CV <= Max - INC                 // Count up of current value
      THEN CV:= CV + INC;
        QU:= FALSE;                    // Upper limit reached
      ELSE QU:= TRUE;
    END_IF;
  UP:= CV;                             // Result of method
  END_METHOD
 
  METHOD PUBLIC UP5: UINT              // Count up by 5
  VAR_OUTPUT QU: BOOL; END_VAR         // Upper limit reached
    UP5:= THIS.UP(INC:= 5, QU => QU);  // Internal method call: The method "UP" of the same function block is called.
  END_METHOD
END_FUNCTION_BLOCK
Beispiel 2: Ein einfaches Beispiel mit Methoden 
PROGRAM ExampleCircle
  VAR
    C1 : CIRCLE; // declaration of a CIRCLE instance
    A : REAL; // circle area
    D : REAL; // circle diameter
    C : REAL; // circle circumference
  END_VAR
    
  // initialize the circle instance with a radius of 7.28
  C1(R := 7.28);
  A := C1.AREA(); // get the area
  D := C1.DIAMETER(); // get the diameter
  C := C1.CIRCUMFERENCE(); // get the circumference
END_PROGRAM
 
FUNCTION_BLOCK CIRCLE
  VAR_INPUT
    R : REAL;
  END_VAR
  VAR CONSTANT
    PI : REAL := 3.1415927;
  END_VAR
    
  // calculate the circle area
  METHOD PUBLIC AREA : REAL
    AREA := PI * R * R;
  END_METHOD
    
  // calculate the diameter
  METHOD PUBLIC DIAMETER : REAL
    DIAMETER := 2 * R;
  END_METHOD
    
  // calculate the circumference
  METHOD PUBLIC CIRCUMFERENCE : REAL
    CIRCUMFERENCE := DIAMETER() * PI;
  END_METHOD  
END_FUNCTION_BLOCK
Beispiel 3: Methoden werden überschrieben. 
FUNCTION_BLOCK LIGHTROOM (* the base function block "LIGHTROOM" *)
  VAR
    LIGHT: BOOL;
  END_VAR
 
  METHOD PUBLIC DAYTIME
    LIGHT := FALSE;
  END_METHOD
 
  METHOD PUBLIC NIGHTTIME
    LIGHT := TRUE;
  END_METHOD
  NIGHTTIME();
  END_FUNCTION_BLOCK
 
FUNCTION_BLOCK LIGHT2ROOM EXTENDS LIGHTROOM (* the derived function block "LIGHT2ROOM" *)
  VAR
    LIGHT2 : BOOL; // 2nd light
  END_VAR
 
  METHOD PUBLIC OVERRIDE DAYTIME // The method 'DAYTIME' is overwritten.  
    LIGHT := FALSE;  // accessing the variable 'LIGHT' of the base function block "LIGHTROOM"
    LIGHT2 := FALSE; // an additional statement
  END_METHOD
 
  METHOD PUBLIC OVERRIDE NIGHTTIME // The method 'NIGHTTIME' is overwritten.   
    LIGHT := TRUE;  // accessing the variable 'LIGHT' of the base function block ""LIGHTROOM"
    LIGHT2 := TRUE; // an additional statement
  END_METHOD
  super(); // This calls the body of parent FB "LIGHTROOM" which itself calls the method "NIGHTTIME". In this case the "NIGHTTIME" implementation from the bottom-most base function block "LIGHT3ROOM" is taken.
  super.NIGHTTIME(); // This calls the method "NIGHTTIME" of the base function block "LIGHTROOM" directly. Here "LIGHT" is set to "TRUE".
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK LIGHT3ROOM EXTENDS LIGHT2ROOM (* the function block "LIGHT3ROOM" - now derived from "LIGHT2ROOM" *)
  VAR
    LIGHT3 : BOOL; // 3rd light
  END_VAR
 
  METHOD PUBLIC OVERRIDE DAYTIME
    LIGHT := FALSE;  // accessing the variable 'LIGHT' of the base function block "LIGHTROOM"
    LIGHT2 := FALSE; // accessing the variable 'LIGHT2' of the base function block "LIGHT2ROOM"
    LIGHT3 := TRUE;  // an additional statement
  END_METHOD
 
  METHOD PUBLIC OVERRIDE NIGHTTIME
    LIGHT := TRUE;   // accessing the variable 'LIGHT' of the base function block "LIGHTROOM"
    LIGHT2 := FALSE; // accessing the variable 'LIGHT2' of the base function block "LIGHT2ROOM"
    LIGHT3 := TRUE;  // an additional statement
  END_METHOD
  super();
END_FUNCTION_BLOCK

Beispiel 4: Abstrakter Funktionsbaustein und abstrakte Methode

 
INTERFACE ISwitch
  METHOD SwitchState
    VAR_INPUT
      STATE : BOOL;
    END_VAR
  END_METHOD
  METHOD SwitchOff
  END_METHOD
END_INTERFACE
 
FUNCTION_BLOCK ABSTRACT MySwitch IMPLEMENTS ISwitch (* the abstract function block = the base function block  *)
  VAR
    switchState : BOOL;
  END_VAR
  METHOD PUBLIC SwitchState
    VAR_INPUT
      STATE : BOOL;
    END_VAR
    switchState := STATE;
  END_METHOD
  METHOD PUBLIC ABSTRACT SwitchOff                (* the abstract method *)
  END_METHOD
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK MySwitch2 EXTENDS MySwitch  (* the non-abstract function block = the derived function block *)
    METHOD PUBLIC OVERRIDE SwitchOff              (* the method overwriting the abstract method of the abstract function block *)
    END_METHOD
END_FUNCTION_BLOCK
Beispiel 5: Funktionsbaustein und Methode mit "FINAL" 
INTERFACE ISwitch
  METHOD SwitchState
    VAR_INPUT
      STATE : BOOL;
    END_VAR
  END_METHOD
  METHOD SwitchOff
  END_METHOD
END_INTERFACE
 
FUNCTION_BLOCK FINAL MySwitch IMPLEMENTS ISwitch  (* a function block that should NOT be used as a base function block - due to "FINAL" *)
  VAR
    switchState : BOOL;
  END_VAR
  METHOD PUBLIC SwitchState
    VAR_INPUT
      STATE : BOOL;
    END_VAR
    switchState := STATE;
  END_METHOD
  METHOD PUBLIC SwitchOff
  END_METHOD
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK MySwitch2 IMPLEMENTS ISwitch  (* a base function block *)
  VAR
    switchState : BOOL;
  END_VAR
  METHOD PUBLIC SwitchState
    VAR_INPUT
      STATE : BOOL;
    END_VAR
    switchState := STATE;
  END_METHOD
  METHOD PUBLIC FINAL SwitchOff                     (* a method that should not be overwritten - due to "FINAL" *)
  END_METHOD
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK MySwitch3 EXTENDS MySwitch    (* An error is reported for this derived function block. Reason: "MySwitch" is using "FINAL" and must not be used as base function block. *)
END_FUNCTION_BLOCK
 
FUNCTION_BLOCK MySwitch4 EXTENDS MySwitch2
  METHOD PUBLIC OVERRIDE SwitchOff           (* An error is reported for this method. Reason: The method "SwitchOff" in the base function block "MySwitch2" is using "FINAL" and must not be overwritten. *)
  END_METHOD
END_FUNCTION_BLOCK
Beispiel 6: Methoden mit unterschiedlicher Sichtbarkeit 
FUNCTION_BLOCK ExampleVisibleMethods
  METHOD PUBLIC m1 : INT       // The method may be called from anywhere.
  END_METHOD
 
  METHOD PRIVATE m2            // The method may only be called from inside this function block "ExampleVisibleMethods".
  END_METHOD
 
  METHOD INTERNAL m3           // The method may be called from inside the same namespace.
  END_METHOD
 
  METHOD PROTECTED m4 : BOOL   // The method may only be called from inside this function block. Moreover, it may be called from functions blocks that are derived from "ExampleVisibleMethods".
  END_METHOD
END_FUNCTION_BLOCK

Weitere Beispiele für Methoden finden Sie unter "Beispiele für Verwendung von Interfaces und Variablen basierend auf diesen Interfaces (inkl. Zuweisungen)" und "Deklaration eines Funktionsbausteins in ST".